/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.util.xml;

import org.springframework.lang.Nullable;

import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.stream.Location;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Comment;
import javax.xml.stream.events.Namespace;
import javax.xml.stream.events.ProcessingInstruction;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.XMLEvent;
import java.util.Iterator;

/**
 * Implementation of the {@link javax.xml.stream.XMLStreamReader} interface that wraps a
 * {@link XMLEventReader}. Useful because the StAX {@link javax.xml.stream.XMLInputFactory}
 * allows one to create a event reader from a stream reader, but not vice-versa.
 *
 * @author Arjen Poutsma
 * @see StaxUtils#createEventStreamReader(javax.xml.stream.XMLEventReader)
 * @since 3.0
 */
class XMLEventStreamReader extends AbstractXMLStreamReader
{

    private final XMLEventReader eventReader;
    private XMLEvent event;


    public XMLEventStreamReader(XMLEventReader eventReader) throws XMLStreamException
    {
        this.eventReader = eventReader;
        this.event = eventReader.nextEvent();
    }

    @SuppressWarnings("rawtypes")
    private static int countIterator(Iterator iterator)
    {
        int count = 0;
        while (iterator.hasNext())
        {
            iterator.next();
            count++;
        }
        return count;
    }

    @Override
    public QName getName()
    {
        if (this.event.isStartElement())
        {
            return this.event.asStartElement().getName();
        }
        else if (this.event.isEndElement())
        {
            return this.event.asEndElement().getName();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    public Location getLocation()
    {
        return this.event.getLocation();
    }

    @Override
    public int getEventType()
    {
        return this.event.getEventType();
    }

    @Override
    @Nullable
    public String getVersion()
    {
        if (this.event.isStartDocument())
        {
            return ((StartDocument) this.event).getVersion();
        }
        else
        {
            return null;
        }
    }

    @Override
    public Object getProperty(String name) throws IllegalArgumentException
    {
        return this.eventReader.getProperty(name);
    }

    @Override
    public boolean isStandalone()
    {
        if (this.event.isStartDocument())
        {
            return ((StartDocument) this.event).isStandalone();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    public boolean standaloneSet()
    {
        if (this.event.isStartDocument())
        {
            return ((StartDocument) this.event).standaloneSet();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    @Nullable
    public String getEncoding()
    {
        return null;
    }

    @Override
    @Nullable
    public String getCharacterEncodingScheme()
    {
        return null;
    }

    @Override
    public String getPITarget()
    {
        if (this.event.isProcessingInstruction())
        {
            return ((ProcessingInstruction) this.event).getTarget();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    public String getPIData()
    {
        if (this.event.isProcessingInstruction())
        {
            return ((ProcessingInstruction) this.event).getData();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    public int getTextStart()
    {
        return 0;
    }

    @Override
    public String getText()
    {
        if (this.event.isCharacters())
        {
            return this.event.asCharacters().getData();
        }
        else if (this.event.getEventType() == XMLEvent.COMMENT)
        {
            return ((Comment) this.event).getText();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    @SuppressWarnings("rawtypes")
    public int getAttributeCount()
    {
        if (!this.event.isStartElement())
        {
            throw new IllegalStateException();
        }
        Iterator attributes = this.event.asStartElement().getAttributes();
        return countIterator(attributes);
    }

    @Override
    public boolean isAttributeSpecified(int index)
    {
        return getAttribute(index).isSpecified();
    }

    @Override
    public QName getAttributeName(int index)
    {
        return getAttribute(index).getName();
    }

    @Override
    public String getAttributeType(int index)
    {
        return getAttribute(index).getDTDType();
    }

    @Override
    public String getAttributeValue(int index)
    {
        return getAttribute(index).getValue();
    }

    @SuppressWarnings("rawtypes")
    private Attribute getAttribute(int index)
    {
        if (!this.event.isStartElement())
        {
            throw new IllegalStateException();
        }
        int      count      = 0;
        Iterator attributes = this.event.asStartElement().getAttributes();
        while (attributes.hasNext())
        {
            Attribute attribute = (Attribute) attributes.next();
            if (count == index)
            {
                return attribute;
            }
            else
            {
                count++;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public NamespaceContext getNamespaceContext()
    {
        if (this.event.isStartElement())
        {
            return this.event.asStartElement().getNamespaceContext();
        }
        else
        {
            throw new IllegalStateException();
        }
    }

    @Override
    @SuppressWarnings("rawtypes")
    public int getNamespaceCount()
    {
        Iterator namespaces;
        if (this.event.isStartElement())
        {
            namespaces = this.event.asStartElement().getNamespaces();
        }
        else if (this.event.isEndElement())
        {
            namespaces = this.event.asEndElement().getNamespaces();
        }
        else
        {
            throw new IllegalStateException();
        }
        return countIterator(namespaces);
    }

    @Override
    public String getNamespacePrefix(int index)
    {
        return getNamespace(index).getPrefix();
    }

    @Override
    public String getNamespaceURI(int index)
    {
        return getNamespace(index).getNamespaceURI();
    }

    @SuppressWarnings("rawtypes")
    private Namespace getNamespace(int index)
    {
        Iterator namespaces;
        if (this.event.isStartElement())
        {
            namespaces = this.event.asStartElement().getNamespaces();
        }
        else if (this.event.isEndElement())
        {
            namespaces = this.event.asEndElement().getNamespaces();
        }
        else
        {
            throw new IllegalStateException();
        }
        int count = 0;
        while (namespaces.hasNext())
        {
            Namespace namespace = (Namespace) namespaces.next();
            if (count == index)
            {
                return namespace;
            }
            else
            {
                count++;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public int next() throws XMLStreamException
    {
        this.event = this.eventReader.nextEvent();
        return this.event.getEventType();
    }

    @Override
    public void close() throws XMLStreamException
    {
        this.eventReader.close();
    }

}
